// pages/community/communityMain/communityMain.js
const api = require('../../../utils/api');

Page({
  data: {
    userInfo: {},          // 当前用户信息（头像、昵称）
    targetUserInfo: null,  // 目标用户信息（设为null，确保不显示其他用户信息）
    myShares: [],          // 当前用户的分享列表
    otherShares: []        // 其他用户的分享列表
  },

  onLoad(options) {
    console.log('社区页面加载，准备获取数据');
    
    // 页面加载时：1. 获取用户信息 2. 获取所有分享内容
    this.getUserInfo();
    // 延迟执行getDynamicList以确保顺序执行
    setTimeout(() => {
      this.getDynamicList();
    }, 300);
  },

  // 获取当前用户信息
  getUserInfo() {
    // 先尝试获取本地存储的登录用户信息
    const loginInfo = wx.getStorageSync('loginInfo');
    const cachedUserInfo = wx.getStorageSync('userInfo');
    
    let currentUserInfo;
    
    // 优先使用登录信息中的用户ID
    if (loginInfo && loginInfo.id) {
      currentUserInfo = {
        id: loginInfo.id,
        userId: loginInfo.id, // 兼容userId字段
        avatar: loginInfo.avatar || '/static/pic/icon-test_2.png',
        avatarUrl: loginInfo.avatar || '/static/pic/icon-test_2.png', // 兼容avatarUrl字段
        username: '我',
        nickname: loginInfo.nickname || '用户'
      };
      console.log('使用登录信息中的用户ID:', loginInfo.id);
    } 
    // 其次使用缓存的用户信息（确保不是ID为1的无效信息）
    else if (cachedUserInfo && (cachedUserInfo.id || cachedUserInfo.userId) && 
             cachedUserInfo.id !== 1 && cachedUserInfo.userId !== 1) {
      currentUserInfo = {
        ...cachedUserInfo,
        username: '我' // 始终显示为'我'
      };
      console.log('使用缓存的用户信息，ID:', cachedUserInfo.id || cachedUserInfo.userId);
    }
    // 最后使用默认用户信息，但避免使用ID 1
    else {
      currentUserInfo = {
        avatarUrl: '/static/pic/icon-test_2.png',
        userId: 11, // 使用正确的默认用户ID
        id: 11, // 添加id字段以保持一致性
        username: '我',
        nickname: '游客'
      };
      console.log('使用默认用户信息，避免使用ID 1');
    }
    
    // 设置用户信息
    this.setData({ userInfo: currentUserInfo });
    
    // 缓存用户信息
    wx.setStorageSync('userInfo', currentUserInfo);
    
    console.log('当前用户信息设置为:', currentUserInfo);
  },
  
  // 格式化分享项数据
  formatShareItem(item, isCurrentUser = false) {
    try {
      if (!item || typeof item !== 'object') {
        return null;
      }
      
      // 获取有效的图片URLs，并处理可能不存在的图片
      const formatImageUrls = (urls) => {
        if (!urls) return [];
        
        // 定义本地默认图片，用于替换404的图片
        const defaultImage = '/static/pic/icon-test_3.png';
        
        // 检查URL是否为OSS上可能不存在的图片
        const isOssMissingImage = (url) => {
          if (typeof url !== 'string') return false;
          // 检查是否包含已知的不存在的OSS路径
          const missingImages = [
            'https://gdufe-anputour.oss-cn-guangzhou.aliyuncs.com/share/diy1.jpg',
            'https://gdufe-anputour.oss-cn-guangzhou.aliyuncs.com/share/diy2.jpg',
            'https://gdufe-anputour.oss-cn-guangzhou.aliyuncs.com/share/diy3.jpg',
            'https://gdufe-anputour.oss-cn-guangzhou.aliyuncs.com/share/mountain1.jpg',
            'https://gdufe-anputour.oss-cn-guangzhou.aliyuncs.com/share/mountain2.jpg'
          ];
          return missingImages.includes(url);
        };
        
        // 处理图片URL数组
        const processUrl = (url) => {
          if (isOssMissingImage(url)) {
            console.log(`检测到不存在的图片URL，已替换为默认图片: ${url}`);
            return defaultImage;
          }
          return url;
        };
        
        if (Array.isArray(urls)) {
          return urls.map(processUrl);
        }
        if (typeof urls === 'string') {
          return [processUrl(urls)];
        }
        return [];
      };
      
      // 获取有效的时间
      const getValidTime = (time) => {
        if (time) return String(time);
        return new Date().toLocaleString('zh-CN');
      };
      
      const itemId = item.id || item.postId || Date.now();
      
      // 获取本地缓存的点赞状态和点赞数
      let isLiked = Boolean(item.isLiked || item.liked);
      let likeCount = Number(item.likeCount || item.like_count || 0);
      
      try {
        const likedPosts = wx.getStorageSync('likedPosts') || {};
        if (likedPosts[itemId] !== undefined) {
          isLiked = likedPosts[itemId].isLiked;
          // 如果缓存中有点赞数，则使用缓存的点赞数
          if (likedPosts[itemId].likeCount !== undefined) {
            likeCount = Number(likedPosts[itemId].likeCount);
          }
          console.log(`从本地缓存应用点赞状态和点赞数: 帖子ID=${itemId}, isLiked=${isLiked}, likeCount=${likeCount}`);
        }
      } catch (error) {
        console.error('读取本地点赞缓存失败:', error);
      }
      
      return {
        id: itemId,
        title: item.title || '',
        description: item.description || item.content || '',
        createUser: item.createUser || item.userId || 1,
        createUserName: isCurrentUser ? '我' : (item.createUserName || `用户${item.createUser || ''}`),
        createTime: getValidTime(item.createTime || item.create_time),
        imageUrls: formatImageUrls(item.imageUrls || item.images || []),
        likeCount: likeCount,
        favoriteCount: Number(item.favoriteCount || item.favorite_count || 0),
        commentCount: Number(item.commentCount || item.comment_count || 0),
        userAvatar: isCurrentUser ? this.data.userInfo.avatarUrl : (item.avatarUrl || '/static/pic/icon-test_2.png'),
        isLiked: isLiked
      };
    } catch (error) {
      console.error('格式化分享项失败:', error);
      return null;
    }
  },
  
  // 从服务器同步用户的点赞状态
  async syncUserLikeStatus() {
    try {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.log('未登录，跳过从服务器同步点赞状态');
        return;
      }
      
      // 导入api
      const api = require('../../../utils/api.js');
      
      console.log('开始从服务器同步用户点赞状态');
      // 确保like接口存在（注意：api.js中导出为'like'而不是'likeApi'）
      if (!api.like) {
        console.error('like接口未定义');
        return;
      }
      
      // 调用接口获取用户的点赞列表（目标类型为1表示帖子）
      const res = await api.like.getUserLikes(1, 50, 1);
      
      if (res && res.code === 0 && res.data && res.data.records) {
        const likedPosts = {};
        const timestamp = new Date().getTime();
        
        // 构建点赞状态映射
        res.data.records.forEach(item => {
          if (item && item.targetId) {
            likedPosts[item.targetId] = {
              isLiked: true,
              timestamp: timestamp
            };
          }
        });
        
        // 合并到本地缓存
        const existingLikedPosts = wx.getStorageSync('likedPosts') || {};
        const mergedLikedPosts = { ...existingLikedPosts, ...likedPosts };
        
        // 保存到本地缓存
        wx.setStorageSync('likedPosts', mergedLikedPosts);
        console.log('从服务器同步点赞状态成功，共', Object.keys(likedPosts).length, '条点赞记录');
        
        // 重新加载分享列表，应用最新的点赞状态
        this.getDynamicList();
      }
    } catch (error) {
      console.error('从服务器同步点赞状态失败:', error);
      // 不影响用户体验，仅记录错误
    }
  },
  
  // 移除重复分享
  removeDuplicateShares(shares) {
    if (!Array.isArray(shares)) return [];
    const uniqueIds = new Set();
    return shares.filter(share => {
      if (!share || !share.id) return false;
      if (uniqueIds.has(share.id)) return false;
      uniqueIds.add(share.id);
      return true;
    });
  },
  
  // 获取当前用户信息和分享
  getCurrentUserAndShares() {
    try {
      // 获取当前用户ID，与getUserInfo方法保持一致的逻辑
      const loginInfo = wx.getStorageSync('loginInfo');
      const userInfo = this.data.userInfo || wx.getStorageSync('userInfo');
      
      // 优先使用登录信息中的ID，其次使用用户信息中的ID
      let currentUserId = loginInfo && (loginInfo.id || loginInfo.userId) ? (loginInfo.id || loginInfo.userId) : 
                         userInfo && (userInfo.id || userInfo.userId) ? (userInfo.id || userInfo.userId) : 2;
      
      // 确保不使用ID为1的无效值
      if (currentUserId === 1) {
        currentUserId = 2; // 使用正确的默认用户ID
      }
      
      console.log('开始获取用户ID为', currentUserId, '的分享列表');
      
      // 尝试从本地存储获取缓存数据，合并cachedMyShares和backupShares
      let localShares = [];
      try {
        // 读取多个存储键的数据，包括可能的编辑后数据
        const cachedShares = wx.getStorageSync('cachedMyShares') || [];
        const backupShares = wx.getStorageSync('backupShares') || [];
        const tempShares = wx.getStorageSync('tempShares') || [];
        
        // 合并多个数据源并去重，优先保留最新的编辑数据（按lastUpdateTime或createTime排序）
        let allShares = [...cachedShares, ...backupShares, ...tempShares];
        
        // 先按时间排序，确保最新编辑的数据在前面
        allShares.sort((a, b) => {
          const timeA = new Date(a.lastUpdateTime || a.createTime || '').getTime();
          const timeB = new Date(b.lastUpdateTime || b.createTime || '').getTime();
          return timeB - timeA; // 降序排列，最新的在前
        });
        
        // 根据ID去重，保留排序后的第一个出现的项（即最新的）
        const uniqueShares = this.removeDuplicateShares(allShares);
        
        // 格式化本地数据
        if (uniqueShares && Array.isArray(uniqueShares)) {
          localShares = uniqueShares
            .map(item => this.formatShareItem(item, true))
            .filter(Boolean);
        }
        
        console.log('已获取本地缓存数据，总共', localShares.length, '条，包含可能的编辑数据');
        
        // 临时显示本地数据以提供更好的用户体验
        if (localShares.length > 0) {
          this.setData({ myShares: localShares });
        }
      } catch (storageError) {
        console.warn('读取本地缓存失败:', storageError);
      }
      
      // 先获取当前用户的分享
      api.community.getUserShares(currentUserId).then(res => {
        try {
          console.log('获取当前用户分享:', res);
          let apiShares = [];
          
          // 处理各种可能的数据格式，确保apiShares始终是数组
          if (res && res.code === 0 && res.data) {
            apiShares = Array.isArray(res.data) ? res.data : [];
          } else if (Array.isArray(res)) {
            apiShares = res;
          } else if (res && typeof res === 'object' && !res.code) {
            // 处理非标准格式响应
            apiShares = Object.values(res).filter(value => 
              value && typeof value === 'object' && (value.id || value.postId)
            );
          }
          
          // 确保apiShares是数组
          if (!Array.isArray(apiShares)) {
            console.error('apiShares不是数组类型，已重置为空数组');
            apiShares = [];
          }
          
          // 格式化API数据
          apiShares = apiShares
            .map(item => this.formatShareItem(item, true))
            .filter(Boolean);
          
          console.log('API数据获取完成，总共', apiShares.length, '条');
          
          // 合并API数据和本地缓存数据，优先保留本地可能有更新的数据
          // 创建所有数据的映射，键为ID，值为数据项
          const allShareMap = new Map();
          
          // 先添加API数据
          apiShares.forEach(share => {
            if (share && (share.id || share.postId)) {
              allShareMap.set(share.id || share.postId, { ...share, source: 'api' });
            }
          });
          
          // 然后添加本地数据，如果有相同ID但本地数据更新，则替换API数据
          localShares.forEach(share => {
            if (share && (share.id || share.postId)) {
              const existingShare = allShareMap.get(share.id || share.postId);
              // 检查是否需要替换API数据为本地数据（例如，本地有lastUpdateTime）
              if (!existingShare || 
                  (share.lastUpdateTime && 
                   (!existingShare.lastUpdateTime || 
                    new Date(share.lastUpdateTime).getTime() > new Date(existingShare.lastUpdateTime).getTime()))) {
                allShareMap.set(share.id || share.postId, { ...share, source: 'local' });
                console.log('使用本地更新的数据替换API数据，ID:', share.id || share.postId);
              }
            }
          });
          
          // 转换Map为数组
          const finalShares = Array.from(allShareMap.values());
          
          console.log('最终合并数据，总计', finalShares.length, '条');
          
          // 缓存数据到本地 - 只缓存API数据，不缓存本地备份数据
          try {
            wx.setStorageSync('cachedMyShares', apiShares);
            console.log('已缓存API分享数据到本地');
          } catch (storageError) {
            console.warn('缓存分享数据失败:', storageError);
          }
          
          // 如果最终没有数据（包括API和本地缓存），使用mock数据
          if (finalShares.length === 0) {
            const mockMyShares = [
              {
                id: 1,
                title: '',
                description: '我的第一条分享',
                createUser: currentUserId,
                createUserName: '我',
                createTime: '2025-09-02 09:53:49',
                imageUrls: [],
                likeCount: 5,
                isLiked: false
              }
            ];
            this.setData({ 
              myShares: mockMyShares,
              isEmpty: false,
              loading: false
            });
          } else {
            // 按时间排序（最新的在前）并只取第一条
            const sortedShares = [...finalShares].sort((a, b) => {
              const timeA = new Date(a.lastUpdateTime || a.createTime || '').getTime();
              const timeB = new Date(b.lastUpdateTime || b.createTime || '').getTime();
              return timeB - timeA; // 降序排列，最新的在前
            });
            
            // 只显示最新两条的帖子
            this.setData({ 
              myShares: sortedShares.slice(0, 2), // 只取最新两条
              isEmpty: false,
              loading: false
            });
            
            console.log('当前用户分享设置完成，包含可能的本地更新数据:', this.data.myShares);
          }
        } catch (error) {
          console.error('处理用户分享数据出错:', error);
          this.setData({ loading: false });
        }
      }).catch(error => {
        console.error('获取用户分享失败:', error);
        // API调用失败时，确保使用本地缓存数据
        try {
          if (localShares.length > 0) {
            // 按时间排序，优先显示最新更新的内容
            const sortedShares = [...localShares].sort((a, b) => {
              const timeA = new Date(a.lastUpdateTime || a.createTime || '').getTime();
              const timeB = new Date(b.lastUpdateTime || b.createTime || '').getTime();
              return timeB - timeA;
            });
            
            // 只显示最新两条的帖子
            this.setData({
              myShares: sortedShares.slice(0, 2), // 只取最新两条
              isEmpty: false,
              loading: false
            });
            console.log('API调用失败，使用本地缓存数据，显示所有分享');
          } else {
            this.setData({ loading: false });
          }
        } catch (e) {
          console.error('使用本地缓存数据失败:', e);
          this.setData({ loading: false });
        }
      });
    } catch (error) {
      console.error('getCurrentUserAndShares整体异常:', error);
      // 最外层错误捕获，确保页面不会崩溃
      const mockMyShares = [
        {
          id: 1,
          title: '',
          description: '我的第一条分享',
          createUser: 1,
          createUserName: '我',
          createTime: '2025-09-02 09:53:49',
          imageUrls: [],
          likeCount: 5,
          isLiked: false
        }
      ];
      // 按时间排序并只取最新一条
      const sortedShares = [...mockMyShares].sort((a, b) => {
        const timeA = new Date(a.createTime || '').getTime();
        const timeB = new Date(b.createTime || '').getTime();
        return timeB - timeA;
      });
      this.setData({ myShares: sortedShares.slice(0, 1) });
    }
  },
  
  // 获取其他用户的分享
  getOtherUsersShares() {
    try {
      console.log('开始获取其他用户分享');
      
      // 尝试从本地存储获取缓存数据
      try {
        const cachedOtherShares = wx.getStorageSync('cachedOtherShares');
        if (cachedOtherShares && Array.isArray(cachedOtherShares)) {
          console.log('使用本地缓存的其他用户分享数据');
          const formattedShares = cachedOtherShares
            .map(item => this.formatShareItem(item, false))
            .filter(Boolean);
          
          if (formattedShares.length > 0) {
            this.setData({ otherShares: formattedShares });
          }
        }
      } catch (storageError) {
        console.warn('读取本地缓存失败:', storageError);
      }
      
      // 改用分页查询方法替代直接按ID查询，避免400错误
      console.log('使用分页查询获取其他用户分享');
      
      // 先获取当前用户ID，避免显示自己的分享
      const loginInfo = wx.getStorageSync('loginInfo');
      const userInfo = this.data.userInfo || wx.getStorageSync('userInfo');
      const currentUserId = loginInfo && (loginInfo.id || loginInfo.userId) ? (loginInfo.id || loginInfo.userId) : 
                         userInfo && (userInfo.id || userInfo.userId) ? (userInfo.id || userInfo.userId) : null;
      
      // 构建查询参数，可以排除当前用户的分享
      const queryParams = {};
      if (currentUserId) {
        queryParams.excludeUserId = currentUserId;
      }
      
      // 调用分页查询接口
      api.community.getSharesByPage(1, 20, queryParams).then(res => {
        try {
          console.log('获取其他用户分享结果:', JSON.stringify(res));
          let apiShares = [];
          
          // 根据API文档处理分页数据结构
          // res.data.code === 200 是request.js中约定的成功状态
          if (res && typeof res === 'object') {
            // 直接使用res作为data（因为request.js已经提取了res.data.data）
            if (typeof res === 'object' && Array.isArray(res.records)) {
              // 情况1: res本身就是PageResult对象，包含records数组
              apiShares = res.records;
              console.log('从records数组提取分享数据，数量:', apiShares.length);
            } else if (Array.isArray(res)) {
              // 情况2: res直接是数组
              apiShares = res;
              console.log('直接使用数组数据，数量:', apiShares.length);
            } else {
              // 情况3: 检查res是否包含其他可能的数据字段
              console.log('未知的数据结构，尝试其他方式提取');
              // 作为兜底，尝试从各种可能的字段中提取数据
              if (res.data && Array.isArray(res.data.records)) {
                apiShares = res.data.records;
              } else if (res.data && Array.isArray(res.data)) {
                apiShares = res.data;
              } else if (Array.isArray(res.items)) {
                apiShares = res.items;
              }
            }
          }
          
          // 确保apiShares是数组
          if (!Array.isArray(apiShares)) {
            console.error('apiShares不是数组类型，已重置为空数组');
            apiShares = [];
          }
          
          console.log('API获取到其他用户分享数据，总共', apiShares.length, '条');
          
          // 格式化API数据
          apiShares = apiShares
            .map(item => this.formatShareItem(item, false))
            .filter(Boolean);
          
          // 保存到缓存
          try {
            wx.setStorageSync('cachedOtherShares', apiShares);
            console.log('已缓存其他用户分享数据');
          } catch (storageError) {
            console.warn('缓存其他用户分享数据失败:', storageError);
          }
          
          // 更新界面数据
          this.setData({
            otherShares: apiShares
          });
          
        } catch (processError) {
          console.error('处理其他用户分享数据时发生错误:', processError);
          // 使用默认mock数据
          this._useDefaultOtherShares();
        }
      }).catch(err => {
        console.error('获取其他用户分享失败:', err);
        // 使用默认mock数据
        this._useDefaultOtherShares();
      });
      
    } catch (error) {
      console.error('getOtherUsersShares整体异常:', error);
      // 使用默认mock数据
      this._useDefaultOtherShares();
    }
  },
  
  // 处理其他用户分享的Promise结果
  _processOtherSharesPromises(promises) {
    try {
      // 确保promises是数组
      if (!Array.isArray(promises)) {
        promises = [];
        console.error('promises不是数组类型，已重置为空数组');
      }
      
      // 等待所有请求完成
      Promise.all(promises).then(results => {
        try {
          // 确保results是数组
          if (!Array.isArray(results)) {
            console.error('results不是数组类型，使用空数组');
            results = [];
          }
          
          // 过滤掉null结果，只保留有效的分享数据
          let validShares = results.filter(share => share !== null);
          
          // 去重
          validShares = this.removeDuplicateShares(validShares);
          
          // 缓存数据到本地
          try {
            wx.setStorageSync('cachedOtherShares', validShares);
          } catch (storageError) {
            console.warn('缓存其他用户分享数据失败:', storageError);
          }
          
          // 如果没有获取到其他用户的分享，使用mock数据
          if (validShares.length === 0) {
            this._useDefaultOtherShares();
          } else {
            this.setData({ otherShares: validShares });
            console.log('其他用户分享设置完成，数量:', this.data.otherShares.length);
          }
        } catch (processError) {
          console.error('处理其他用户分享结果时发生错误:', processError);
          this._useDefaultOtherShares();
        }
      }).catch(err => {
        console.error('Promise.all执行失败:', err);
        this._useDefaultOtherShares();
      });
    } catch (error) {
      console.error('_processOtherSharesPromises异常:', error);
      this._useDefaultOtherShares();
    }
  },
  
  // 使用默认的其他用户分享数据
  _useDefaultOtherShares() {
    try {
      const mockOtherShares = [
        {
          id: 2,
          title: '旅行见闻',
          description: '今天去了一个美丽的地方，风景真不错！分享给大家。',
          createUser: 2,
          createUserName: '旅行达人',
          createTime: '2025-09-01 15:30:20',
          imageUrls: [],
          likeCount: 12,
          isLiked: false
        },
        {
          id: 3,
          title: '美食推荐',
          description: '这家餐厅的特色菜非常好吃，环境也很棒！',
          createUser: 3,
          createUserName: '美食家',
          createTime: '2025-08-30 19:45:10',
          imageUrls: [],
          likeCount: 8,
          isLiked: false
        },
        {
          id: 4,
          title: '生活随笔',
          description: '记录一下最近的生活点滴，平凡中的美好。',
          createUser: 4,
          createUserName: '生活家',
          createTime: '2025-08-29 14:20:30',
          imageUrls: [],
          likeCount: 5,
          isLiked: false
        }
      ];
      this.setData({ otherShares: mockOtherShares });
      console.log('使用默认其他用户分享数据，数量:', this.data.otherShares.length);
    } catch (error) {
      console.error('_useDefaultOtherShares异常:', error);
      // 最后兜底，确保页面有数据显示
      this.setData({ otherShares: [] });
    }
  },
  
  // 获取动态列表（整合当前用户和其他用户的分享）
  getDynamicList() {
    try {
      console.log('开始获取动态列表');
      
      // 先显示加载中状态
      wx.showLoading({
        title: '加载中...',
      });
      
      // 先清空现有数据，避免显示旧数据
      this.setData({
        myShares: [],
        otherShares: []
      });
      
      // 先从服务器同步用户点赞状态
      this.syncUserLikeStatus().then(() => {
        // 分别获取当前用户和其他用户的分享
        // 为了确保数据加载的可靠性，添加延时和重试机制
        try {
          this.getCurrentUserAndShares();
        } catch (error) {
          console.error('获取当前用户分享异常:', error);
          // 即使出错也不影响其他功能
        }
        
        // 延迟获取其他用户分享，避免请求冲突
        setTimeout(() => {
          try {
            this.getOtherUsersShares();
          } catch (error) {
            console.error('获取其他用户分享异常:', error);
          } finally {
            // 无论如何都要隐藏加载状态
            setTimeout(() => {
              wx.hideLoading();
            }, 500);
          }
        }, 300);
      });
    } catch (error) {
      console.error('getDynamicList整体异常:', error);
      // 确保隐藏加载状态
      wx.hideLoading();
      // 显示错误提示
      wx.showToast({
        title: '加载动态失败',
        icon: 'none'
      });
    }
  },
  
  // 跳转到用户分享历史页面
  gotoUserShare(e) {
    const userId = e.currentTarget.dataset.userid;
    const username = e.currentTarget.dataset.username;
    wx.navigateTo({
      url: `/pages/community/userShare/userShare?userId=${userId}&username=${encodeURIComponent(username)}`
    });
  },
  
  // 修改分享
  editShare(e) {
    const id = e.currentTarget.dataset.id;
    const desc = e.currentTarget.dataset.desc;
    
    wx.showModal({
      title: '修改分享',
      content: '确定要修改这条分享吗？',
      success: (res) => {
        if (res.confirm) {
          // 构建修改数据
          const updateData = {
            id: id,
            content: desc
          };
          
          // 调用API修改分享
          api.community.updateShare(updateData).then(() => {
            wx.showToast({
              title: '修改成功',
              icon: 'success'
            });
            // 刷新分享列表
            this.getDynamicList();
          }).catch(err => {
            console.error('修改分享失败:', err);
            wx.showToast({
              title: '修改失败，请重试',
              icon: 'none'
            });
          });
        }
      }
    });
  },
  
  // 删除分享
  deleteShare(e) {
    const id = e.currentTarget.dataset.id;
    
    wx.showModal({
      title: '删除分享',
      content: '确定要删除这条分享吗？',
      success: (res) => {
        if (res.confirm) {
          // 调用API删除分享
          api.community.deleteShare(id).then(() => {
            wx.showToast({
              title: '删除成功',
              icon: 'success'
            });
            // 刷新分享列表
            this.getDynamicList();
          }).catch(err => {
            console.error('删除分享失败:', err);
            wx.showToast({
              title: '删除失败，请重试',
              icon: 'none'
            });
          });
        }
      }
    });
  },
  
  // 分享功能已移除
  
  // 跳转到我的分享历史页面
  gotoMyShare() {
    wx.navigateTo({
      url: '/pages/community/myShare/myShare'
    });
  },
  
  // 切换点赞状态
  toggleLike(e) {
    try {
      // 安全获取事件参数
      if (!e || !e.currentTarget || !e.currentTarget.dataset) {
        console.error('toggleLike: 无效的事件参数');
        return;
      }
      
      const postId = e.currentTarget.dataset.id;
      const shareType = e.currentTarget.dataset.type;
      
      // 参数验证
      if (!postId || !shareType) {
        console.error('toggleLike: 缺少必要参数');
        return;
      }
      
      console.log(`切换分享 ${postId} 的点赞状态，类型: ${shareType}`);
      
      // 根据类型选择要更新的数组
      const targetArray = shareType === 'myShare' ? 'myShares' : 'otherShares';
      const currentArray = this.data[targetArray];
      
      // 数组有效性检查
      if (!Array.isArray(currentArray)) {
        console.error(`toggleLike: ${targetArray} 不是数组`);
        return;
      }
      
      try {
        // 查找并更新对应分享项的点赞状态
        const updatedArray = currentArray.map(item => {
          // 确保item是有效对象
          if (!item || typeof item !== 'object') {
            return item;
          }
          
          if (item.id === postId) {
            const newIsLiked = !Boolean(item.isLiked);
            // 更新点赞数，确保数值安全
            const currentLikeCount = Number(item.likeCount || 0);
            const newLikeCount = newIsLiked ? 
              currentLikeCount + 1 : 
              Math.max(0, currentLikeCount - 1);
            
            return {
              ...item,
              isLiked: newIsLiked,
              likeCount: newLikeCount
            };
          }
          return item;
        });
        
        // 更新数据
        this.setData({
          [targetArray]: updatedArray
        });
        
        // 安全获取更新后的状态
        const updatedItem = updatedArray.find(item => item && item.id === postId);
        if (updatedItem) {
          console.log(`分享 ${postId} 点赞状态切换为: ${updatedItem.isLiked}，点赞数: ${updatedItem.likeCount}`);
          
          // 调用API保存点赞状态到服务器
          this.saveLikeToServer(postId, updatedItem.isLiked);
          
          // 保存点赞状态和点赞数到本地缓存
          this.saveLikeToCache(postId, updatedItem.isLiked, updatedItem.likeCount, shareType);
        }
      } catch (updateError) {
        console.error('更新点赞状态时发生错误:', updateError);
        // 显示错误提示
        wx.showToast({
          title: '操作失败，请重试',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('toggleLike整体异常:', error);
      // 显示错误提示
      wx.showToast({
        title: '操作失败',
        icon: 'none'
      });
    }
  },
  
  // 调用API保存点赞状态到服务器
  async saveLikeToServer(postId, isLiked) {
    try {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.log('未登录，跳过服务器保存');
        return;
      }
      
      // 导入api
      const api = require('../../../utils/api.js');
      
      console.log(`保存点赞状态到服务器: 帖子ID=${postId}, 点赞=${isLiked}`);
      await api.like.changeLike(postId, isLiked, 7); // 使用targetType=7，按照要求设置正确的值
      console.log('点赞状态保存到服务器成功');
    } catch (error) {
      console.error('保存点赞状态到服务器失败:', error);
      // 不影响用户体验，仅记录错误
    }
  },
  
  // 保存点赞状态和点赞数到本地缓存
  saveLikeToCache(postId, isLiked, likeCount, shareType) {
    try {
      console.log(`保存点赞状态和点赞数到本地缓存: 帖子ID=${postId}, 点赞=${isLiked}, 点赞数=${likeCount}`);
      
      // 获取现有点赞缓存
      let likedPosts = wx.getStorageSync('likedPosts') || {};
      
      // 更新点赞状态和点赞数
      likedPosts[postId] = {
        isLiked: isLiked,
        likeCount: likeCount,
        timestamp: new Date().getTime()
      };
      
      // 保存到本地缓存
      wx.setStorageSync('likedPosts', likedPosts);
      console.log('点赞状态和点赞数保存到本地缓存成功');
      
      // 同时更新对应分享列表的缓存
      if (shareType === 'myShare') {
        this.updateCachedMyShares(postId, isLiked, likeCount);
      } else {
        this.updateCachedOtherShares(postId, isLiked, likeCount);
      }
    } catch (error) {
      console.error('保存点赞状态和点赞数到本地缓存失败:', error);
    }
  },
  
  // 更新我的分享缓存中的点赞状态和点赞数
  updateCachedMyShares(postId, isLiked, likeCount) {
    try {
      const cachedMyShares = wx.getStorageSync('cachedMyShares') || [];
      const updatedShares = cachedMyShares.map(item => {
        if (item && item.id === postId) {
          return {
            ...item,
            isLiked: isLiked,
            likeCount: likeCount
          };
        }
        return item;
      });
      wx.setStorageSync('cachedMyShares', updatedShares);
    } catch (error) {
      console.error('更新我的分享缓存失败:', error);
    }
  },
  
  // 更新其他用户分享缓存中的点赞状态和点赞数
  updateCachedOtherShares(postId, isLiked, likeCount) {
    try {
      const cachedOtherShares = wx.getStorageSync('cachedOtherShares') || [];
      const updatedShares = cachedOtherShares.map(item => {
        if (item && item.id === postId) {
          return {
            ...item,
            isLiked: isLiked,
            likeCount: likeCount
          };
        }
        return item;
      });
      wx.setStorageSync('cachedOtherShares', updatedShares);
    } catch (error) {
      console.error('更新其他用户分享缓存失败:', error);
    }
  },

  // 显示点赞用户列表
  showLikeUsers(e) {
    try {
      // 安全获取事件参数
      if (!e || !e.currentTarget || !e.currentTarget.dataset) {
        console.error('showLikeUsers: 无效的事件参数');
        return;
      }
      
      const postId = e.currentTarget.dataset.id;
      const shareType = e.currentTarget.dataset.type;
      
      // 参数验证
      if (!postId) {
        console.error('showLikeUsers: 缺少必要参数');
        return;
      }
      
      console.log(`查看分享 ${postId} 的点赞用户列表`);
      
      // 显示加载中
      wx.showLoading({
        title: '加载中...',
      });
      
      // 导入api
      const api = require('../../../utils/api.js');
      
      // 调用API获取点赞用户列表（使用targetType=1表示帖子类型）
      api.likeApi.getUserLikes(1, 20, 1).then(res => {
        wx.hideLoading();
        
        // 验证响应数据
        if (!res || !res.data || !Array.isArray(res.data.records)) {
          console.error('getUserLikes: 无效的响应数据');
          wx.showToast({
            title: '获取点赞用户失败',
            icon: 'none'
          });
          return;
        }
        
        // 过滤出当前帖子的点赞用户
        const likeUsers = res.data.records.filter(like => like.targetId === postId);
        
        // 如果没有点赞用户
        if (likeUsers.length === 0) {
          wx.showToast({
            title: '暂无点赞用户',
            icon: 'none'
          });
          return;
        }
        
        // 构建用户列表字符串
        const userNames = likeUsers.map(user => user.userName || '用户').join('、');
        
        // 显示点赞用户列表
        wx.showModal({
          title: '点赞用户',
          content: userNames,
          showCancel: true,
          cancelText: '关闭',
          success: (res) => {
            if (res.confirm) {
              // 如果需要进一步操作可以在这里处理
            }
          }
        });
      }).catch(err => {
        wx.hideLoading();
        console.error('获取点赞用户列表失败:', err);
        
        // 由于接口可能在开发中，提供mock数据作为兜底
        const mockLikeUsers = [];
        for (let i = 1; i <= 3; i++) {
          mockLikeUsers.push({ userName: `用户${i}` });
        }
        
        const userNames = mockLikeUsers.map(user => user.userName).join('、');
        
        wx.showModal({
          title: '点赞用户 (模拟数据)',
          content: userNames,
          showCancel: true,
          cancelText: '关闭'
        });
      });
    } catch (error) {
      wx.hideLoading();
      console.error('showLikeUsers整体异常:', error);
      wx.showToast({
        title: '加载失败',
        icon: 'none'
      });
    }
  }
});